<!DOCTYPE html>
<html>
  <head>
    <title>
      Test Different PeriodicWave Lengths at Different Sample Rates
    </title>
    <script src="../../resources/testharness.js"></script>
    <script src="../../resources/testharnessreport.js"></script>
    <script src="../resources/audit-util.js"></script>
    <script src="../resources/audit.js"></script>
  </head>
  <body>
    <script id="layout-test-code">
      // Test PeriodicWave objects with varying number of coefficients at
      // different sample rates. Basically, verify that the coefficients are
      // used at the appropriate sample rates.  This is done by comparing the
      // outputs of two periodic waves used in oscillators.  The output should
      // either be exactly zero or not depending on whether the coefficients
      // were used.

      let renderLength = 1;
      let context;

      let audit = Audit.createTaskRunner();

      // The set of Audit tests to be run to verify that PeriodicWave is using
      // the correct number of coefficients.  The name does not have to be
      // unique; the index of the entry is appended to the test.  Every entry
      // (except the last) needs sampleRate, bigWave, smallWave, and verifier
      // values.

      let testSet = [
        // Tests for contexts at 192 kHz.

        // Test that we use more than 2048 Fourier coefficients at 192 kHz
        // sample rate.  Basically verifies that 8192 is acceptable.
        {
          name: '192khz-test-1',
          sampleRate: 192000,
          bigWave: 8192,
          smallWave: 2048,
          verifier: resultShouldBeNonZero
        },

        // Test that we use at least 2049 Fourier coefficients at 192 kHz sample
        // rate.
        {
          name: '192khz-test-2',
          sampleRate: 192000,
          bigWave: 2049,
          smallWave: 2048,
          verifier: resultShouldBeNonZero
        },

        // Test that we use all 8192 Fourier coefficients at 192 kHz sample
        // rate.
        {
          name: '192khz-test-3',
          sampleRate: 192000,
          bigWave: 8192,
          smallWave: 8191,
          verifier: resultShouldBeNonZero
        },

        // Tests for contexts at 48 kHz.

        // Test that we do not use more than 2048 Fourier coefficients at 48
        // kHz.  This depends on the internal implementation where, for backward
        // compatibility and speed, we only use 2048 coefficients at 48 kHz.
        // (This is also true for rates below 88.2 kHz.)  Also tests that 8192
        // coefficients are allowed (but not all coefficients are used, of
        // course).
        {
          name: '48khz-test-1',
          sampleRate: 48000,
          bigWave: 8192,
          smallWave: 2048,
          verifier: resultShouldBeZero
        },

        // Test that we do not use more than 2048 Fourier coefficients.
        {
          name: '48khz-test-2',
          sampleRate: 48000,
          bigWave: 2049,
          smallWave: 2048,
          verifier: resultShouldBeZero
        },

        // It's not immediately clear with single-preicison arithmetic that we
        // can distinguish between 2049 and 2048 coefficients, so do one more
        // test with slightly more coefficients.
        {
          name: '48khz-test-3',
          sampleRate: 48000,
          bigWave: (2 + 1 / 64) * 1024,
          smallWave: 2048,
          verifier: resultShouldBeZero
        },

        // Test that we use at least 2048 Fourier coefficients at 48 kHz.
        // Ideally we want to compare 2047 and 2048 coefficients, but
        // single-precision arithmetic makes the resulting waveforms the same.
        // Hence use a smaller value that produces different waveforms.
        {
          name: '48khz-test-4',
          sampleRate: 48000,
          bigWave: 2048,
          smallWave: 2046,
          verifier: resultShouldBeNonZero
        },

        // Tests for contexts at 24 kHz.

        // Test that we do not use more than 1024 Fourier coefficients at 24
        // kHz.
        {
          name: '24khz-test-1',
          sampleRate: 24000,
          bigWave: 8192,
          smallWave: 1024,
          verifier: resultShouldBeZero
        },

        // Test that we do not use more than 1024 Fourier coefficients at 24
        // kHz.
        {
          name: '24khz-test-2',
          sampleRate: 24000,
          bigWave: 1025,
          smallWave: 1024,
          verifier: resultShouldBeZero
        },

        // Test that we use at least 1024 Fourier coefficients at 24 kHz.
        // Again, 1023 and 1024 produce the same waveforms in single-precisiion
        // so use a smaller wave table size.
        {
          name: '24khz-test-3',
          sampleRate: 24000,
          bigWave: 1024,
          smallWave: 1022,
          verifier: resultShouldBeNonZero
        },
      ];

      function generatePrefix(sampleRate, bigLength, smallLength) {
        return 'At ' + (sampleRate / 1000) + ' kHz, PeriodicWave with ' +
            bigLength + ' coefficients vs ' + smallLength + ': ';
      }

      // Returns a function the verifies that the result is zero.  The
      // parameters control what is printed in the messages.
      function resultShouldBeZero(should, sampleRate, bigLength, smallLength) {
        return function(buffer) {
          let prefix = generatePrefix(sampleRate, bigLength, smallLength);
          should(isBufferZero(buffer), prefix + 'are identical')
              .beEqualTo(true);
        }
      }

      // Returns a function the verifies that the result is non-zero.  The
      // parameters control what is printed in the messages.
      function resultShouldBeNonZero(
          should, sampleRate, bigLength, smallLength) {
        return function(buffer) {
          let prefix = generatePrefix(sampleRate, bigLength, smallLength);
          should(!isBufferZero(buffer), prefix + 'are different')
              .beEqualTo(true);
        }
      }

      // Creates a function that is used to run an Audit test for a given sample
      // rate, periodic wave sizes, and verifier.
      function createAuditTestFunction(
          sampleRate, bigLength, smallLength, verifier) {
        return (task, should) => {
          // Create the audio graph, render it, and then verify that the output
          // is the expected result.
          createAudioGraph(sampleRate, bigLength, smallLength);

          return context.startRendering()
              .then(verifier(should, sampleRate, bigLength, smallLength))
              .then(() => task.done());
        }
      }

      // Create the audio graph for the test.
      function createAudioGraph(
          sampleRate, bigPeriodicWaveLength, smallPeriodicWaveLength) {
        context =
            new OfflineAudioContext(1, renderLength * sampleRate, sampleRate);

        // Two PeriodicWave objects are created with different sizes (small and
        // big).  The contents are the same except that the samll sized
        // PeriodicWave has fewer coefficients.
        let smallWaveRealCoef = new Float32Array(smallPeriodicWaveLength);
        let smallWaveImagCoef = new Float32Array(smallPeriodicWaveLength);
        let bigWaveRealCoef = new Float32Array(bigPeriodicWaveLength);
        let bigWaveImagCoef = new Float32Array(bigPeriodicWaveLength);

        // Set up the Fourier coefficients for a sawtooth wave.  We use
        // sawtooth because all coefficients are non-zero
        bigWaveImagCoef[0] = 0;
        for (let k = 1; k < bigPeriodicWaveLength; k++) {
          let piFactor = 2 / (Math.PI * k);
          bigWaveImagCoef[k] = piFactor * ((k % 2 === 0) ? -1 : 1);
          if (k < smallPeriodicWaveLength)
            smallWaveImagCoef[k] = bigWaveImagCoef[k];
        }

        let smallPeriodicWave =
            context.createPeriodicWave(smallWaveRealCoef, smallWaveImagCoef);
        let bigPeriodicWave =
            context.createPeriodicWave(bigWaveRealCoef, bigWaveImagCoef);

        // Create oscillators using these PeriodicWave's.
        let smallOscillator = context.createOscillator();
        let bigOscillator = context.createOscillator();

        smallOscillator.setPeriodicWave(smallPeriodicWave);
        bigOscillator.setPeriodicWave(bigPeriodicWave);

        // Use a frequency of 1 Hz to make the distinction easier.  Can't tell
        // from this test, but if you plot the signals from these oscillators,
        // it's very clear that they are different.
        smallOscillator.frequency.value = 1;
        bigOscillator.frequency.value = 1;

        // The desired output is the difference between these oscillators.
        let gain = context.createGain();
        gain.gain.value = -1;
        smallOscillator.connect(gain);

        gain.connect(context.destination);
        bigOscillator.connect(context.destination);

        // Start the oscillators.
        smallOscillator.start();
        bigOscillator.start();
      }

      // Return true if the buffer is exactly zero.
      function isBufferZero(buffer) {
        if (buffer.getChannelData(0).find(function(x) {
              return x != 0;
            }))
          return false;
        return true;
      }

      // Ensure the actual Audit test name is unique by prepending an index to
      // the provided test name.
      function actualTestName(name, index) {
        return index + ':' + name;
      }

      // Define the tasks based on the entries in testSet.
      function defineAuditTests() {
        for (let k = 0; k < testSet.length; ++k) {
          let {name, sampleRate, bigWave, smallWave, verifier} = testSet[k];
          let actualName = actualTestName(name, k);
          audit.define(
              actualName,
              createAuditTestFunction(
                  sampleRate, bigWave, smallWave, verifier));
        }
      }

      defineAuditTests();
      audit.run();
    </script>
  </body>
</html>
